The present invention relates to a memory management system for a process formulated in the C/C++ language in a processing unit. It has a particularly useful application in long-running IT programs or applications such as server applications. These applications must keep the usage of their memory stable over time.
In general, there are two types of memory usage:                the quantity of memory which the process actually uses, called “heap usage”, which must be stable, otherwise the process risks encountering memory problems        the quantity of memory which the operating system reserves for the process, called “virtual memory usage”. It comprises the heap usage as well as libraries and the code of the application.        
Memory fragmentation is the difference between virtual memory usage and heap usage. It is the memory which the system reserves, and contains nothing useful for the process. It cannot be zero, but must be kept as low as possible. If memory fragmentation continues to increase, serious problems can occur:                as the virtual memory increases, this puts more pressure on the operating system, and degrades performance as a whole, sometimes by a very significant factor;        for 32-bit applications, the quantity of available virtual memory is limited to 4 gigabytes or less, depending on what platform is used. Such an application would then lack virtual memory and be interrupted.        
Some programming languages such as Java or NET solve the problem of memory fragmentation by moving objects in memory, i.e. they can “compact” the heap.
This solution is impossible with C or C++ applications, where objects have a fixed address in memory until they are freed.
In particular, existing C/C++ allocators have one or more of the following weaknesses:                the default memory allocator cannot implement internal fragmentation correctly, because of an inadequate block coalescing algorithm. If the size classes which the allocator controls do not suit the sizes which the process uses, this will increase internal fragmentation.        external fragmentation can also not be implemented correctly using a weak coalescing algorithm. Coalescing free blocks is generally very resource-intensive, but it is an obligatory stage for limiting external fragmentation.        
One of the technical problems is therefore the fact that fragmentation consumes time and resources, which in the end penalizes other applications of the system.